home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / DTP / DTP_TEX / 3238.ZIP / DVIEPS2.ZIP / DVIBIT.C < prev    next >
C/C++ Source or Header  |  1988-12-01  |  8KB  |  293 lines
  1. /*=======================================================================
  2. *    Program : dvibit.c
  3. *    Purpose : bitmap related code for eps device driver
  4. *       Date : Oct 1988
  5. *========================================================================
  6. *   Compiler : Microsoft V5.1 C Compiler
  7. *     Linker : Microsoft V3.61 Linker
  8. * Enviroment : MS-DOS 3.21
  9. *========================================================================
  10. * Edit History
  11. *
  12. *   /  /   -gbm- 
  13. *
  14. *======================================================================*/
  15.  
  16. #include "dvidefs.h"
  17. #include "dvivars.h"
  18. #include <sys\types.h>
  19. #include <sys\stat.h>
  20. #include <fcntl.h>
  21.  
  22. extern double mag_table[99];
  23.  
  24. void getbmap()
  25.    {
  26.    int i;
  27.    char *tcp;
  28.    char fname[100];
  29.  
  30.    if (bitmap == (unsigned long int*)NULL)
  31.       {
  32.       bitmap = malloc(25000);
  33.       if (bitmap == (char *)NULL)
  34.          (void)fatal("getbmap():  Cannot allocate space for page image bitmap");
  35.       if ((tcp = getenv("EPSBMAP")) == (char *)NULL)
  36.          strcpy(fname, "BMAP.TMP");
  37.       else
  38.          strcpy(fname, tcp);
  39.       bmap_file = open(fname, O_BINARY | O_CREAT | O_TRUNC | O_RDWR ,S_IREAD | S_IWRITE);
  40.       if (bmap_file == -1)
  41.          (void)fatal("getbmap():  Cannot allocate temporary file");
  42.       clrbmap();
  43.       }
  44.    }
  45.  
  46. void clrbmap()
  47.    {
  48.    int i;
  49.  
  50.    lseek(bmap_file, 0L, SEEK_SET);
  51.    for (i=0; i<25; i++)
  52.       {
  53.       memset((char *)bitmap, 0, 24000);
  54.       if (write(bmap_file, (char*)bitmap, 24000) != 24000)
  55.          (void)fatal("getbmap():  Cannot clear temporary file");
  56.       }
  57.    memset((char *)bitmap, 0, 24000);
  58.    y_file = 0;
  59.    y_min = 5000;
  60.    y_max = -1;  /* ???????????????? */
  61.    }
  62.  
  63. /* return a long int pointer to the yth block of 1920 bits */   
  64. /* these pointers are read in 24000 bytes at a time */
  65.  
  66. unsigned long int *rd_bitmap(int y, int x)
  67.    {
  68.    int new_y, bl, tt;
  69.    long int li;
  70.  
  71.    if (x < 0 || y < 0 || x > 60 || y > 2376)
  72.       {
  73.       printf("\nBitmap read out of range X = %d, Y = %d\n", x, y);
  74.       (void)fatal("rd_bitmap():  Out of range pointer");
  75.       }
  76.  
  77.    if (y < y_min || y > y_max)
  78.       {
  79.       
  80.       /* flush current */
  81.       lseek(bmap_file, 240L * (long int)y_file, SEEK_SET);
  82.       if (write(bmap_file, (char*)bitmap, 24000) != 24000)
  83.          (void)fatal("rd_bitmap():  Cannot flush bitmap");
  84.  
  85.       /* get the new position 30 rasters less than expected*/
  86.       tt = y - 30;
  87.       if (tt < 0)
  88.          new_y = 0;
  89.       else
  90.          new_y = tt;
  91.       y_min = new_y;
  92.       y_max = new_y + 100;
  93.  
  94.       lseek(bmap_file, 240L * (long int)new_y, SEEK_SET);
  95.       if ((bl = (unsigned int)read(bmap_file, (char*)bitmap, 24000)) != 24000)
  96.          {
  97.          printf("\n<%d bytes read, should be 24000>", bl);
  98.          (void)fatal("rd_bitmap():  Cannot read bitmap");
  99.          }
  100. //      printf("(%d->%d=%d)", y_file, new_y, y);
  101.       y_file = new_y;
  102.       }
  103.    return (long int *)((long int)bitmap +
  104.       (y - y_file) * 240L + (long int)(x * 4));
  105.    }
  106.  
  107.  
  108.  
  109. void prtbmap()
  110.    {
  111.    register int i;
  112.    int j;
  113.    int l;
  114.    int ybottom;
  115.    int ytop;
  116.    int second = 0;            /* address second byte if not zero */
  117.  
  118.    int k32;
  119.    unsigned long int bitwise[24][XSIZE/32]; /* block of main bitmap */
  120.    unsigned long int maskl;
  121.  
  122.    unsigned char r[3][XSIZE];            /* vertical 8-bit raster encodings */
  123.    unsigned char maskc;
  124.    unsigned long int *p;            /* pointer into bitmap[][] */
  125.    int k;
  126.  
  127.  
  128.    fprintf(stderr, "p");
  129.    if (kbhit())
  130.       {
  131.       getch();
  132.       (void)fatal("prtbmap(): Operator abort");
  133.       }
  134.    (void)clearerr(plotfp);
  135.  
  136.    ytop = YBIT - 1;
  137.    ybottom = 0;
  138.  
  139.    paperfeeding = 0;            /* for outpaperfeed() */
  140.    (void)fprintf(plotfp, "\0333%c",  0);            /* no paperfeeding */
  141.  
  142.    for (j = ytop - 24; j >= ybottom; j -= 24)
  143.       {                  
  144.       for (k = 0, i = 24; k < 24; k++, i--)
  145.          {
  146.          p = rd_bitmap(j+i, 0);
  147.          (void)memcpy((char *)bitwise[k], (char *)p, XSIZE/8);
  148.          }
  149.  
  150.       (void)memset(r[0], 0, XSIZE);
  151.       (void)memset(r[1], 0, XSIZE);
  152.       (void)memset(r[2], 0, XSIZE);
  153.  
  154.       maskl = 0x80000000L; /* just in case */
  155.  
  156.       for (k = 0; k < XSIZE; k++)
  157.          {
  158.          if ((k % 32) == 0)
  159.             maskl = 0x80000000L;
  160.          k32 = k / 32;
  161.  
  162.          maskc = 0x80;
  163.          if (bitwise[0][k32] & maskl)
  164.             r[0][k] |= maskc;
  165.          if (bitwise[1][k32] & maskl)
  166.             r[1][k] |= maskc;
  167.          if (bitwise[2][k32] & maskl)
  168.             r[2][k] |= maskc;
  169.          maskc >>= 1;
  170.          if (bitwise[3][k32] & maskl)
  171.             r[0][k] |= maskc;
  172.          if (bitwise[4][k32] & maskl)
  173.             r[1][k] |= maskc;
  174.          if (bitwise[5][k32] & maskl)
  175.             r[2][k] |= maskc;
  176.          maskc >>= 1;
  177.          if (bitwise[6][k32] & maskl)
  178.             r[0][k] |= maskc;
  179.          if (bitwise[7][k32] & maskl)
  180.             r[1][k] |= maskc;
  181.          if (bitwise[8][k32] & maskl)
  182.             r[2][k] |= maskc;
  183.          maskc >>= 1;
  184.          if (bitwise[9][k32] & maskl)
  185.             r[0][k] |= maskc;
  186.          if (bitwise[10][k32] & maskl)
  187.             r[1][k] |= maskc;
  188.          if (bitwise[11][k32] & maskl)
  189.             r[2][k] |= maskc;
  190.          maskc >>= 1;
  191.          if (bitwise[12][k32] & maskl)
  192.             r[0][k] |= maskc;
  193.          if (bitwise[13][k32] & maskl)
  194.             r[1][k] |= maskc;
  195.          if (bitwise[14][k32] & maskl)
  196.             r[2][k] |= maskc;
  197.          maskc >>= 1;
  198.          if (bitwise[15][k32] & maskl)
  199.             r[0][k] |= maskc;
  200.          if (bitwise[16][k32] & maskl)
  201.             r[1][k] |= maskc;
  202.          if (bitwise[17][k32] & maskl)
  203.             r[2][k] |= maskc;
  204.          maskc >>= 1;
  205.          if (bitwise[18][k32] & maskl)
  206.             r[0][k] |= maskc;
  207.          if (bitwise[19][k32] & maskl)
  208.             r[1][k] |= maskc;
  209.          if (bitwise[20][k32] & maskl)
  210.             r[2][k] |= maskc;
  211.          maskc >>= 1;
  212.          if (bitwise[21][k32] & maskl)
  213.             r[0][k] |= maskc;
  214.          if (bitwise[22][k32] & maskl)
  215.             r[1][k] |= maskc;
  216.          if (bitwise[23][k32] & maskl)
  217.             r[2][k] |= maskc;
  218.  
  219.          maskl >>= 1;
  220.          }
  221.  
  222.       outline((char *)&r[0][0]);
  223.       (void)outpaperfeed(1);
  224.       outline((char *)&r[1][0]);
  225.       (void)outpaperfeed(1);
  226.       outline((char *)&r[2][0]);
  227.       (void)outpaperfeed(22);
  228.  
  229.       } 
  230.  
  231.    (void)fputs("\0332", plotfp);            /* ESC 2 = normal paperfeeding */
  232.    (void)putc((char)('\f'), plotfp);                /* eject page with FF */
  233.  
  234.    (void)fflush(plotfp);
  235.    if (DISKFULL(plotfp))
  236.       (void)fatal("prtbmap(): Output error -- disk storage probably full");
  237.    }
  238.  
  239.  
  240. void outline(pline)
  241. char *pline;
  242.    {
  243.    register char* a;
  244.    register char* b;
  245.    register char* c;
  246.    register int left;
  247.    int len;
  248.    int linelength;
  249.    char resolution;
  250.    unsigned char spacing;
  251.    unsigned char space_width;
  252.  
  253.    linelength = XSIZE;
  254.  
  255.    for ((left = XSIZE, c = pline + linelength - 1);
  256.          (*c == '\000') && (left > 0);
  257.          (--left, --c))            /* trim white space */
  258.       ;
  259.  
  260.    if (left == 0)
  261.       return;        /* NEWLINE() is not needed for any paperfeeding */
  262.  
  263.    (void)outpaperfeed(0);        /* print accumulated paperfeedings */
  264.  
  265.    if (left > 0)
  266.       {
  267.       (void)fprintf(plotfp, "\033*%c%c%c", 3, left % 256, left / 256);
  268.       for (c = pline; left; --left, c++)
  269.          (void)putc((char)(*c), plotfp);
  270.       }
  271. /*   (void)putc((char)10, plotfp);  fix by NEP  88-12-01  */
  272.     (void)putc((char)13, plotfp);
  273.    }
  274.  
  275. void outpaperfeed(count)        /* accumulate 1/216 inch paperfeedings */
  276. int count;            /* and write them out if count == 0 */
  277.    {
  278.  
  279.    register int k;
  280.  
  281.    if (count)
  282.       paperfeeding += count;
  283.    else
  284.       {
  285.       for (k = paperfeeding / 255; k; --k)
  286.          (void)fprintf(plotfp, "\033J%c",  255);
  287.       if ((k = paperfeeding % 255) > 0)
  288.          (void)fprintf(plotfp, "\033J%c",  k);
  289.       paperfeeding = 0;
  290.       }
  291.    }
  292.  
  293.